"""
学生管理路由模块

提供教师端学生管理相关的功能，包括：
1. 页面路由：
   - /students: 学生管理页面，显示学生列表
2. API路由：
   - GET /api/students: 获取学生列表，支持分页
   - GET /api/students/<student_number>: 获取单个学生信息
   - POST /api/students: 创建新学生
   - PUT /api/students/<student_number>: 更新学生信息
   - DELETE /api/students/<student_number>: 删除学生
   - GET /api/students/search: 搜索学生，支持按学号和姓名搜索

所有API路由都需要教师登录权限，使用teacher_login_required装饰器进行保护。
"""

from flask import Blueprint, render_template, request, jsonify
from flask_login import login_required, current_user
from ..models.database import db
from ..models.models import Student, Class, College, Teacher
from .tea_auth import teacher_login_required, add_registration
from .tea_utils import get_paginated_results, get_common_data, teacher_required

# 创建蓝图，用于组织相关的路由
bp = Blueprint('teacher_student', __name__, url_prefix='/teacher')

# ==================== 页面路由 ====================
@bp.route('/students')
@teacher_login_required  # 需要教师登录才能访问
@add_registration       # 添加注册信息
def students(registration):
    """
    学生管理页面路由
    
    显示学生列表，支持分页显示。该路由：
    1. 需要教师登录权限
    2. 自动添加教师注册信息
    3. 显示学生列表，包含班级和学院信息
    4. 提供分页功能
    5. 包含通用数据（班级列表、学院列表等）
    
    Args:
        registration: 教师注册信息，由add_registration装饰器提供
        
    Returns:
        str: 渲染后的HTML页面，包含：
            - registration: 教师注册信息
            - students: 分页后的学生列表
            - 其他通用数据（班级列表、学院列表等）
    """
    page = request.args.get('page', 1, type=int)  # 获取页码，默认为1
    per_page = 20  # 每页显示20条记录
    
    # 构建查询：获取学生信息及其班级、学院名称
    students_query = db.session.query(
        Student,
        Class.class_name,
        College.college_name
    ).select_from(Student).join(
        Class, Student.class_id == Class.class_id
    ).join(
        College, Class.college_id == College.college_id
    ).order_by(Student.student_number.desc())  # 按学号降序排序
    
    # 获取分页结果
    pagination = students_query.paginate(page=page, per_page=per_page)
    
    # 获取通用数据（如班级列表、学院列表等）
    common_data = get_common_data()
    
    # 渲染模板，传递所需数据
    return render_template('teacher/students.html', 
                         registration=registration,
                         students=pagination,
                         **common_data)

# ==================== API路由 ====================
@bp.route('/api/students')
@teacher_login_required
def get_students():
    """
    获取学生列表API，支持分页和模糊搜索（search参数）。
    Query Parameters:
        page (int): 当前页码，默认为1
        search (str): 搜索关键词（可选，支持学号/姓名模糊查）
    Returns:
        dict: JSON响应，包含：
            - success: 请求是否成功
            - students: 学生信息列表
            - pagination: 分页信息
    """
    page = request.args.get('page', 1, type=int)
    per_page = 20
    search_text = request.args.get('search', '')
    # 查询学生及其班级名称
    query = db.session.query(
        Student,
        Class.class_name
    ).join(
        Class, Student.class_id == Class.class_id
    )
    # 搜索条件
    if search_text:
        query = query.filter(
            db.or_(
                Student.student_number.ilike(f'%{search_text}%'),
                Student.name.ilike(f'%{search_text}%')
            )
        )
    query = query.order_by(Student.student_number.desc())
    # 分页
    pagination = query.paginate(page=page, per_page=per_page)
    # 组装学生信息为dict列表
    students = [
        {
            'student_number': s.student_number,
            'name': s.name,
            'gender': s.gender,
            'class_id': s.class_id,
            'class_name': class_name
        }
        for s, class_name in pagination.items
    ]
    # 返回统一结构
    return jsonify({
        'success': True,
        'students': students,
        'pagination': {
            'total': pagination.total,
            'pages': pagination.pages,
            'current_page': pagination.page,
            'has_next': pagination.has_next,
            'has_prev': pagination.has_prev
        }
    })

@bp.route('/api/students/<student_number>')
@teacher_login_required
def get_student(student_number):
    """
    获取单个学生信息的API
    
    根据学号获取学生详细信息，包括：
    - 学号
    - 姓名
    - 性别
    - 班级ID
    - 班级名称
    - 学院名称
    
    Args:
        student_number (str): 学生学号
        
    Returns:
        dict: JSON响应，包含：
            - success: 请求是否成功
            - data: {
                'student_number': str,
                'name': str,
                'gender': str,
                'class_id': int,
                'class_name': str,
                'college_name': str
            }
            
    Raises:
        404: 学生不存在
    """
    student = Student.query.filter_by(student_number=student_number).first_or_404()
    return jsonify({
        'success': True,
        'data': student.to_dict()
    })

@bp.route('/api/students', methods=['POST'])
@teacher_login_required
def create_student():
    """
    创建新学生的API
    
    创建新的学生记录，需要提供：
    - 姓名
    - 学号
    - 性别
    - 班级ID
    
    该API会：
    1. 验证必要字段
    2. 检查学号是否重复
    3. 创建新学生记录
    
    Request Body:
        {
            'name': str,           # 学生姓名
            'student_number': str, # 学号
            'gender': str,         # 性别
            'class_id': int        # 班级ID
        }
        
    Returns:
        dict: JSON响应，包含：
            - success: 请求是否成功
            - data: 新创建的学生信息（如果成功）
            - message: 错误信息（如果失败）
            
    Status Codes:
        201: 创建成功
        400: 请求参数错误或创建失败
    """
    data = request.get_json()
    
    # 验证请求数据
    if not data:
        return jsonify({'success': False, 'message': '请求体为空'}), 400
    
    # 检查必要字段
    required_fields = ['name', 'student_number', 'gender', 'class_id']
    for field in required_fields:
        if field not in data:
            return jsonify({'success': False, 'message': f'缺少必要字段: {field}'}), 400
    
    try:
        # 检查学号是否已存在
        if Student.query.filter_by(student_number=data['student_number']).first():
            return jsonify({'success': False, 'message': '学号已存在'}), 400
        
        # 创建新学生记录
        student = Student(
            name=data['name'],
            student_number=data['student_number'],
            gender=data['gender'],
            class_id=data['class_id']
        )
        db.session.add(student)
        db.session.commit()
        return jsonify({
            'success': True,
            'data': student.to_dict()
        }), 201
    except Exception as e:
        db.session.rollback()
        return jsonify({'success': False, 'message': str(e)}), 400

@bp.route('/api/students/<student_number>', methods=['PUT'])
@teacher_login_required
def update_student(student_number):
    """
    更新学生信息的API
    
    更新指定学生的信息，可以修改：
    - 姓名
    - 性别
    - 班级ID
    
    该API会：
    1. 验证学生是否存在
    2. 更新指定字段
    3. 保存更改
    
    Args:
        student_number (str): 要更新的学生学号
        
    Request Body:
        {
            'name': str,     # 新的姓名（可选）
            'gender': str,   # 新的性别（可选）
            'class_id': int  # 新的班级ID（可选）
        }
        
    Returns:
        dict: JSON响应，包含：
            - success: 请求是否成功
            - data: 更新后的学生信息（如果成功）
            - message: 错误信息（如果失败）
            
    Status Codes:
        200: 更新成功
        400: 请求参数错误或更新失败
        404: 学生不存在
    """
    student = Student.query.filter_by(student_number=student_number).first_or_404()
    data = request.get_json()
    
    if not data:
        return jsonify({'success': False, 'message': '请求体为空'}), 400
    
    try:
        # 更新学生信息
        if 'name' in data:
            student.name = data['name']
        if 'gender' in data:
            student.gender = data['gender']
        if 'class_id' in data:
            student.class_id = data['class_id']
        
        db.session.commit()
        return jsonify({
            'success': True,
            'data': student.to_dict()
        })
    except Exception as e:
        db.session.rollback()
        return jsonify({'success': False, 'message': str(e)}), 400

@bp.route('/api/students/<student_number>', methods=['DELETE'])
@teacher_login_required
def delete_student(student_number):
    """
    删除学生的API
    
    删除指定的学生记录。该API会：
    1. 验证学生是否存在
    2. 删除学生记录
    3. 处理可能的关联数据（如成绩记录）
    
    Args:
        student_number (str): 要删除的学生学号
        
    Returns:
        dict: JSON响应，包含：
            - success: 请求是否成功
            - message: 成功或错误信息
            
    Status Codes:
        200: 删除成功
        400: 删除失败
        404: 学生不存在
        
    Note:
        删除学生可能会影响关联的成绩记录，需要谨慎操作
    """
    student = Student.query.filter_by(student_number=student_number).first_or_404()
    try:
        db.session.delete(student)
        db.session.commit()
        return jsonify({'success': True})
    except Exception as e:
        db.session.rollback()
        return jsonify({'success': False, 'message': str(e)}), 400 